test(vi-mock): inherit the real @object-ui/plugin-list surface in 9 vi.mock factories (objectui#6892 slice 12) - #8250

Part of #6892 (slice 12: @object-ui/plugin-list)

Nine vi.mock('@object-ui/plugin-list', ...) factories under
packages/app-shell/src/views hand-listed ListView and froze the barrel's other
eleven exports at whatever was typed that day. Each now spreads the real module
first and keeps its own ListView double as the override after it, so only the
SURFACE the double sits on becomes real. The specifier joins COVERED_SPECIFIERS
in the same PR, per the gate's documented widening precondition.

No assertion, no test behaviour, no product source and no package.json is
touched. The diff is nine factory headers, the gate's covered set and header
record, and one empty-frontmatter changeset.

Bases. Branch cut from 190cd07b3 (the slice-11 merge). origin/main moved
twice mid-slice, so it was merged in twice with merge commits (never rebased) and
every reading below was re-taken on the merged head: c85116068, then
31a0d055b. Final head f4c9a8768; every exit code below is pinned to it.

⚠️ Notation: a few spellings below are written in words rather than literally,
because GitHub's body sanitizer silently deletes tag-shaped fragments (AGENTS.md,
"GitHub 会改写你写进 issue/PR 正文的字节"). Where the repair's type argument is
described, the generic brackets around typeof import('@object-ui/plugin-list')
are omitted from the prose and live only in the diff.

STEP 0 — PROCEED

Method. The static import graph was walked from packages/plugin-list/src/index.tsx
with the TypeScript parser, every module-scope statement of every reached module
classified, and import-time effects re-classified by a second AST pass that STOPS at
every function-like boundary (a statement-level regex over the same graph reports 18
"effects", and all 18 are matches inside arrow-function bodies that do not run at
import — prefer the parser). Aliases were read out of vitest.config.mts itself;
TS ESM './x.js' specifiers resolved to ./x.ts / ./x.tsx. Corroborated
empirically by importing the real barrel under the light dom project, which is
the single project all ten sites run in.

Graph. 539 modules, 5,777 module-scope statements (2,376 import/export, 1,226
fn/class, 967 bindings, 803 type declarations, 405 other) over twelve workspace
packages: components 206, core 95, fields 77, react 64, i18n 27, types 17, mobile
16, permissions 10, plugin-list 8, sdui-parser 8, data-objectstack 6, providers 5.
98 bare side-effect imports (the @object-ui/components renderer cascade) and one
CSS import, inert because the root Vitest config declares no css option.

Registrations — NOT inert, and every one namespaced. 115 module-scope
ComponentRegistry.register(...) calls, ZERO of them bare: ui 85, element 10,
page 7, action 5, plugin-list 2, view 1. The five rows in
packages/components/src/renderers/layout/page.tsx that READ as bare carry
namespace: 'ui' through the spread pageMeta constant declared at page.tsx:662
— the namespace lives in register()'s THIRD argument, never in the key — so the
deprecation console.warn in register() cannot fire. Beyond registration the
graph is allocation only: 173 React.forwardRef, 84 new Set, 21 createContext,
16 Object.freeze, 13 new Map, 13 cva, 13 createSafeTranslation, 10
createDiscardProofCache, plus the benign packages/fields class slice 7 already
measured (five registerFieldRenderer map writes, one setCellRendererResolver
assignment, registerAllFields()). ZERO timers, globals, storage, fetch and
connections at import time.

Empirically, importing the real barrel under the light dom project exports
12 names, moves ComponentRegistry.getAllTypes() from 0 to 375 keys, and emits
ZERO console.warn and ZERO console.error (three runs, identical).

Import cost — decided on the AGGREGATE

Each per-file figure is the median of three runs. The aggregate was taken as an
INTERLEAVED A/B against the committed tree under a trap, because this shared box
drifted by ten seconds across the hour (the same ten files read 37.25 s median
early and 26.6 s median later, in the same frozen state). One pair alone would have
"decided" the slice in either direction; the two together read as noise. Nowhere
near objectui#6580's STOP band.

Mechanism, measured rather than argued. Every one of the ten files already
holds 515 to 539 of the barrel's 539 modules at module scope — the three view
components under test (ObjectView.tsx, InterfaceListPage.tsx,
ObjectDataPage.tsx) each import ListView from this specifier and their own
graphs pull the rest. Inheriting adds 8 modules in seven files and 24 in the other
two. That is why the marginal is uniform and small, and not slice 10's bimodal
shape.

Slice 11's deferred-cost class does not fire. No React.lazy and no dynamic
import() of @object-ui/plugin-list exists anywhere in packages/ or apps/
(two greps, both empty). All three consuming views import it at MODULE SCOPE, so
the inheritance cost lands in the import phase where no timeout applies. No file
needed a module-scope import, and no timeout was touched.

STEP 1 — the census, through the gate's own scan()

Re-derived on 190cd07b3 with scan() imported and covered widened IN MEMORY to
the 22 workspace specifiers any vi.mock call site names. COVERED_SPECIFIERS was
never widened-and-reverted on disk.

All-specifier population: 40 to 31 frozen over 660 judged, and a diff of the two
per-specifier tables with the @object-ui/plugin-list row removed is EMPTY — no
site moved the other way. The PM's 10 / 1 / 9 forecast is EXACT, as is the owning
location: all ten sit in one directory, packages/app-shell/src/views.

Three syntactic shapes, not one — a refinement on the dispatch, which described
the double as the schema-columns renderer. Only one of the nine is that:

• 4 one-line object-literal arrows whose ListView double returns null;
• 3 multi-line ones whose double captures props.schema into a module-level
  binding and returns null;
• 2 whose double renders a JSX probe element carrying a data-testid and a
  JSON-serialised slice of props.schema.

Each hand-listed exactly ONE of the barrel's twelve exports. Every double is
unchanged by this PR; only the surface it sits on becomes real. None of the nine
reads a prop the real ListView would not — all three shapes read props.schema
or a path under it, which ListViewProps declares (A5: no phantom prop taught).

The free confirmation is present, and it is the strongest kind for this slice.
ObjectView.chartRelay-7823.test.tsx already inherited the real barrel on main,
passes, and carries a frozen sonner neighbour of its own — so the real barrel was
known to load in the light dom project ALONGSIDE that neighbour before anything
was converted. None of the ten is in heavyDomTests or domTsTests; all ten are
.test.tsx under the light dom project, so one environment is the whole answer.

Neighbour reading — ZERO repairs, predicted in advance

Every OTHER factory in all ten files was classified through the gate's own
findCallSites BEFORE any edit, then judged against the walked graph.

⚠️ The sonner pairing is the interesting one, and the neighbour rule as
previously stated would have predicted a repair. This barrel's graph DOES reach
sonner — three imports — and seven of the ten files carry a frozen sonner
factory, which is exactly the pairing that killed 15 files in slice 6. It is benign
here for a reason worth recording: the two renderer modules that import it read
toast.success and friends only INSIDE their click handlers, and
packages/components/src/ui/sonner.tsx re-exports toast at module scope but
dereferences the Toaster binding only inside a component body. The frozen
factories all provide toast. So the sharper rule is: a frozen neighbour is
dangerous when the newly-real graph reads a MISSING BINDING from it AT MODULE
SCOPE — reach alone is necessary, not sufficient. The two react-router-dom
factories are safe by reach: no module in the graph imports it at all (the two
matches are prose in comments).

No file among the ten mocks @object-ui/app-shell — re-derived on this base,
confirming the PM's comm reading of 0. The parked specifier (objectui#8173) stays
parked and untouched.

Dependency-edge reading

packages/app-shell/package.json declares @object-ui/plugin-list as a
workspace:^ PEER dependency at line 104 and a workspace:* DEV dependency at
line 121; apps/console/package.json declares it as a workspace:* DEV dependency
at line 82. All ten converted files live in packages/app-shell, so app-shell's
pair is the one that licenses the repair's type argument; the console edge is
recorded but unused by this slice. pnpm check:phantom-deps exits 0 on the final
head (40 released packages, 3,988 source files, 20,215 specifiers).

Covered set: sixteen to seventeen

Exactly one line added to COVERED_SPECIFIERS ('@object-ui/plugin-list', exact
string match), the header count word sixteen to seventeen, the slice-12
per-specifier record added in the shape slices 5 to 11 used, and the
remaining-population paragraph refreshed 40 to 31 with @object-ui/app-shell
re-annotated as PARKED under objectui#8173. The remaining rows are
@object-ui/app-shell (23, all frozen, parked) and @object-ui/fields (8 of 10).

The record was written WITHOUT the shape objectui#8117's pin rejects; a mechanical
grep -nP over the whole gate source for that pattern returns 0 matches. The pin
needed no edit — confirmed by RUNNING it, exit 0, 67/67, file unedited: it still
derives its names from COVERED_SPECIFIERS rather than copying them.

Positive control — two legs, from the committed tree

Both legs ran under a trap with ABSOLUTE paths against
packages/app-shell/src/views/ObjectView.createPredicates.test.tsx, HEAD blob
8aa55c0ab80622062fbb4e7740ce0ec45a2cfc7d. Each mutation is proven ON DISK by a
count anchored on the plugin-list spread line SPECIFICALLY (this file carries three
other spreads, so a file-wide count would never fall to zero) AND by a changed blob,
before the gate result is read. Each restore is proven by STATE, never by a checkout
exit code.

Both legs name ObjectView.createPredicates.test.tsx:103 on
vi.mock("@object-ui/plugin-list"). Leg 1 is objectui#8183's canonical control
shape, not the mention-only one. Leg 2's blob is BYTE-IDENTICAL to this file at the
base 190cd07b3, so the leg provably reconstructed the exact frozen form the gate
must reject. The anchored count read 1 to 0 on both legs; after each restore
git hash-object equalled the HEAD blob and git diff HEAD named zero paths, and
git status was empty at the end. No dist preflight is owed: the gate is a
source-text scanner that reads tracked paths from disk, and both configs alias the
specifier to source.

Gates — every exit code pinned to f4c9a8768

Each captured by redirect-then-capture, never through a pipe.

The whole-package lints cover every changed path, so the targeted eslint run
above is corroboration rather than a narrowing. Type-aware linting is NOT enabled
in eslint.config.js (no project / projectService), so this diff cannot move
the verdict on any file it does not touch.

Live E2E (informational) is base-red on every branch today for an upstream reason
(#7990 / objectstack#16186) and is not this PR's.

Slice 13 forecast

@object-ui/fields — 10 judged / 2 inheriting / 8 frozen on f4c9a8768, the only
remaining row once @object-ui/app-shell (23 of 23) is skipped as PARKED under
objectui#8173. It has a free confirmation, as this slice did.

🤖 Generated with Claude Code

https://claude.ai/code/session_01FhBNJcLRZLe8M87VcUgpKr

Generated by Claude Code